package Thread.Safe;

/**
 * 线程安全的synchronized关键字
 * 针对每一把锁, 操作系统内部都维护了一个等待队列. 当这个锁被某个线程占有的时候, 其他线程尝
 * 试进行加锁, 就加不上了, 就会阻塞等待, 一直等到之前的线程解锁之后, 由操作系统唤醒一个新的
 * 线程, 再来获取到这个锁.
 */
public class Threadsynchronized {
    public static class Counter{
        int count = 0;
        //synchronized 会起到互斥效果, 某个线程执行到某个对象的 synchronized 中时,其他线程如果也执行到同一个对象 synchronized 就会阻塞等待.
        synchronized void increase() throws InterruptedException {
            System.out.println(Thread.currentThread().getName()+"获取到锁~~");
            count++;
            Thread.sleep(1000);
        }
    }
    public static void main(String[] args) throws InterruptedException {
        ThreadSafeorUnsafe.Counter counter=new ThreadSafeorUnsafe.Counter();
        Thread t1=new Thread(()->{
            for (int i = 0; i <50000 ; i++) {
                counter.increase();
            }
        });
        Thread t2=new Thread(()->{
            for (int i = 0; i <50000 ; i++) {
                counter.increase();
            }
        });
        t1.start();
        t1.join();
        t2.start();
        t2.join();
        //主线程走到此处，t1和t2都已经执行结束，理性状态是count和等于1万
        System.out.println("t1和t2已经执行完毕~~");
        System.out.println(counter.count);
    }
}
